/*
 * [The "BSD license"]
 *  Copyright (c) 2012 Terence Parr
 *  Copyright (c) 2012 Sam Harwell
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.codefinger.dao.antlr.v4.runtime.misc;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Utils {
	// Seriously: why isn't this built in to java? ugh!
	public static <T> String join(Iterator<T> iter, String separator) {
		StringBuilder buf = new StringBuilder();
		while (iter.hasNext()) {
			buf.append(iter.next());
			if (iter.hasNext()) {
				buf.append(separator);
			}
		}
		return buf.toString();
	}

	public static <T> String join(T[] array, String separator) {
		StringBuilder builder = new StringBuilder();
		for (int i = 0; i < array.length; i++) {
			builder.append(array[i]);
			if (i < array.length - 1) {
				builder.append(separator);
			}
		}

		return builder.toString();
	}

	public static int numNonnull(Object[] data) {
		int n = 0;
		if (data == null)
			return n;
		for (Object o : data) {
			if (o != null)
				n++;
		}
		return n;
	}

	public static <T> void removeAllElements(Collection<T> data, T value) {
		if (data == null)
			return;
		while (data.contains(value))
			data.remove(value);
	}

	public static String escapeWhitespace(String s, boolean escapeSpaces) {
		StringBuilder buf = new StringBuilder();
		for (char c : s.toCharArray()) {
			if (c == ' ' && escapeSpaces)
				buf.append('\u00B7');
			else if (c == '\t')
				buf.append("\\t");
			else if (c == '\n')
				buf.append("\\n");
			else if (c == '\r')
				buf.append("\\r");
			else
				buf.append(c);
		}
		return buf.toString();
	}

	public static void writeFile(String fileName, String content) throws IOException {
		writeFile(fileName, content, null);
	}

	public static void writeFile(String fileName, String content, String encoding) throws IOException {
		File f = new File(fileName);
		FileOutputStream fos = new FileOutputStream(f);
		OutputStreamWriter osw;
		if (encoding != null) {
			osw = new OutputStreamWriter(fos, encoding);
		} else {
			osw = new OutputStreamWriter(fos);
		}

		try {
			osw.write(content);
		} finally {
			osw.close();
		}
	}

	public static char[] readFile(String fileName) throws IOException {
		return readFile(fileName, null);
	}

	public static char[] readFile(String fileName, String encoding) throws IOException {
		File f = new File(fileName);
		int size = (int) f.length();
		InputStreamReader isr;
		FileInputStream fis = new FileInputStream(fileName);
		if (encoding != null) {
			isr = new InputStreamReader(fis, encoding);
		} else {
			isr = new InputStreamReader(fis);
		}
		char[] data = null;
		try {
			data = new char[size];
			int n = isr.read(data);
			if (n < data.length) {
				data = Arrays.copyOf(data, n);
			}
		} finally {
			isr.close();
		}
		return data;
	}

	public static void waitForClose(final Window window) throws InterruptedException {
		final Object lock = new Object();

		Thread t = new Thread() {
			@Override
			public void run() {
				synchronized (lock) {
					while (window.isVisible()) {
						try {
							lock.wait(500);
						} catch (InterruptedException e) {
						}
					}
				}
			}
		};

		t.start();

		window.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent arg0) {
				synchronized (lock) {
					window.setVisible(false);
					lock.notify();
				}
			}
		});

		t.join();
	}

	/**
	 * Convert array of strings to string&rarr;index map. Useful for converting
	 * rulenames to name&rarr;ruleindex map.
	 */
	public static Map<String, Integer> toMap(String[] keys) {
		Map<String, Integer> m = new HashMap<String, Integer>();
		for (int i = 0; i < keys.length; i++) {
			m.put(keys[i], i);
		}
		return m;
	}

	public static char[] toCharArray(IntegerList data) {
		if (data == null)
			return null;
		char[] cdata = new char[data.size()];
		for (int i = 0; i < data.size(); i++) {
			cdata[i] = (char) data.get(i);
		}
		return cdata;
	}

	public static IntervalSet toSet(BitSet bits) {
		IntervalSet s = new IntervalSet();
		int i = bits.nextSetBit(0);
		while (i >= 0) {
			s.add(i);
			i = bits.nextSetBit(i + 1);
		}
		return s;
	}
}
